#ifndef HASHROW_H_JM_20120826
#define HASHROW_H_JM_20120826


#include <vector>
#include <functional>

namespace jm4bbx {

	template<class T>
	class HashRow {
	public:

		/**
		* Typ ukladanych hodnot.
		**/
		typedef T ValueType;
		typedef std::pair<ValueType, int> ExtendedValueType;

		typedef std::function<bool(ValueType&)> ForechValueFunType;
		typedef std::function<bool(ExtendedValueType&)> ForechExtendedValueFunType;

		//typedef void (*ForechFunType)(const ValueType& entry);
		/**
		* Typ kontajneru pre vsetky hodnoty v riadku.
		**/
		typedef std::vector<ExtendedValueType> MultiValueType;

		/**
		* Pridanie hodnoty do riadku.
		* @param value hodnota pridavana do riadku
		**/
		virtual int add(const ValueType& value) = 0;

		/**
		* Vrati hodnotu ulozenu v riadku na zadanom indexe.
		* @param index umiestenie pozadovanej hodnoty v riadku
		**/
		virtual ExtendedValueType getExtendedValue(const size_t& index) const = 0;

		/**
		* Je riadok prazdny?
		**/
		virtual bool isEmpty() const = 0;

		/**
		* Zmazanie vsetkych hodnot v riadku.
		**/
		virtual void clear() = 0;

		/**
		* Pocet hodnot v riadku.
		**/
		virtual size_t distinctSize() const = 0;

		/**
		* Pre kazdu hodnotu v riadku vykonaj akciu.
		* 
		* @param functor vykonavatel akcie na jednotlivych hodnotach v riadku
		* @tparam T typ funktora, ktory vykona akciu jednotlivo na kazdej hodnote 
		* v riadku tj. operator()(ValueType)
		**/
		//template<class T>
		//void foreach(const T& functor) { };

		virtual std::pair<int, int> foreach(ForechValueFunType fun, const std::pair<int, int>& iterationContext) = 0;
		virtual int foreachExtended(ForechExtendedValueFunType fun, int iterationContext) = 0;

		virtual HashRow<T>* getLockFreeInstance() = 0;
		virtual HashRow<T>* getLockableInstance() = 0;

	};





	///**
	//* Riadok hodnot hashovacej tabulky {@link HashTableCore}. Riadok moze byt 
	//* tvoreny vacerymi hodno pri kolizi. Implementacia je thread-safe.
	//* 
	//* @tparam T typ ukladanych hodnot.
	//**/
	//template<class T>
	//class HashRow {
	//public:
	//	/**
	//	* Typ ukladanych hodnot.
	//	**/
	//	typedef T ValueType;

	//	/**
	//	* Typ kontajneru pre vsetky hodnoty v riadku.
	//	**/
	//	typedef std::vector<ValueType> MultiValueType;

	//	/**
	//	* Pridanie hodnoty do riadku.
	//	* @param value hodnota pridavana do riadku
	//	**/
	//	void add(const ValueType& value) {
	//		boost::mutex::scoped_lock lock(mutex_);
	//		values_.push_back(value);
	//	}

	//	/**
	//	* Vrati hodnotu ulozenu v riadku na zadanom indexe.
	//	* @param index umiestenie pozadovanej hodnoty v riadku
	//	**/
	//	T get(const size_t& index) const {
	//		boost::mutex::scoped_lock lock(mutex_);
	//		return values_[index];
	//	}

	//	/**
	//	* Je riadok prazdny?
	//	**/
	//	bool isEmpty() const {
	//		boost::mutex::scoped_lock lock(mutex_);
	//		return values_.empty();
	//	}

	//	/**
	//	* Zmazanie vsetkych hodnot v riadku.
	//	**/
	//	void clear() const {
	//		boost::mutex::scoped_lock lock(mutex_);
	//		values_.clear();
	//	}

	//	/**
	//	* Pocet hodnot v riadku.
	//	**/
	//	size_t size() const {
	//		boost::mutex::scoped_lock lock(mutex_);
	//		return values_.size();
	//	}

	//	/**
	//	* Pre kazdu hodnotu v riadku vykonaj akciu.
	//	* 
	//	* @param functor vykonavatel akcie na jednotlivych hodnotach v riadku
	//	* @tparam T typ funktora, ktory vykona akciu jednotlivo na kazdej hodnote 
	//	* v riadku tj. operator()(ValueType)
	//	**/
	//	template<class T>
	//	void foreach(const T& functor) {
	//		boost::mutex::scoped_lock lock(mutex_);
	//		for (size_t i = 0; i < values_.size(); ++i) {
	//			functor(values_[i]);
	//		}
	//	}

	//private:
	//	/// Hodnoty v riadku
	//	MultiValueType values_;
	//	/// Mutex pre zabezpecenie paralelneho pristupu k riadku
	//	mutable boost::mutex mutex_;
	//};


} // namespace jm4bbx

#endif
